package com.zuo_book.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zuo_book.common.BusinessException;
import com.zuo_book.common.ResultCode;
import com.zuo_book.entity.*;
import com.zuo_book.mapper.*;
import com.zuo_book.service.SysTemplateService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 项目模板服务实现类
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class SysTemplateServiceImpl implements SysTemplateService {

    private final SysTemplateMapper templateMapper;
    private final SysTemplateStageMapper templateStageMapper;
    private final SysTemplateReviewMapper templateReviewMapper;
    private final SysTemplateUserMapper templateUserMapper;
    private final UserMapper userMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createTemplate(SysTemplateBo template) {
        // 插入模板
        SysTemplate sysTemplate  = new SysTemplate();
        BeanUtils.copyProperties(template, sysTemplate);
        sysTemplate.setCreateTime(LocalDateTime.now());
        templateMapper.insert(sysTemplate);
        List<SysTemplateStage> stages = template.getStages();
        for (SysTemplateStage stage : stages) {
            stage.setTemplateId(sysTemplate.getId());
            stage.setCreateTime(LocalDateTime.now());
            templateStageMapper.insert(stage);
        }
        return template.getId();
    }

    @Override
    public void updateTemplate(SysTemplate template) {
        // 检查模板是否存在
        SysTemplate existingTemplate = templateMapper.selectById(template.getId());
        if (existingTemplate == null) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "模板不存在");
        }
        
        // 更新模板
        templateMapper.updateById(template);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteTemplate(Long templateId) {
        // 检查模板是否存在
        SysTemplate template = templateMapper.selectById(templateId);
        if (template == null) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "模板不存在");
        }
        
        // 删除模板阶段
        LambdaQueryWrapper<SysTemplateStage> stageWrapper = new LambdaQueryWrapper<>();
        stageWrapper.eq(SysTemplateStage::getTemplateId, templateId);
        templateStageMapper.delete(stageWrapper);
        
        // 删除模板评价
        LambdaQueryWrapper<SysTemplateReview> reviewWrapper = new LambdaQueryWrapper<>();
        reviewWrapper.eq(SysTemplateReview::getTemplateId, templateId);
        templateReviewMapper.delete(reviewWrapper);
        
        // 删除模板购买记录
        LambdaQueryWrapper<SysTemplateUser> userWrapper = new LambdaQueryWrapper<>();
        userWrapper.eq(SysTemplateUser::getTemplateId, templateId);
        templateUserMapper.delete(userWrapper);
        
        // 删除模板
        templateMapper.deleteById(templateId);
    }

    @Override
    public SysTemplate getTemplateById(Long templateId) {
        SysTemplate template = templateMapper.selectById(templateId);
        if (template == null) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "模板不存在");
        }
        return template;
    }

    @Override
    public Page<SysTemplate> listTemplates(int page, int size, String keyword, String category,String isReview) {
        // 创建分页对象
        Page<SysTemplate> pageParam = new Page<>(page, size);
        
        // 构建查询条件
        LambdaQueryWrapper<SysTemplate> wrapper = new LambdaQueryWrapper<>();
        if (StringUtils.hasText(keyword)) {
            wrapper.like(SysTemplate::getTemplateName, keyword)
                   .or()
                   .like(SysTemplate::getTemplateCode, keyword)
                   .or()
                   .like(SysTemplate::getDescription, keyword);
        }
        if (StringUtils.hasText(category)) {
            wrapper.eq(SysTemplate::getCategory, category);
        }
        if (StringUtils.hasText(isReview)){
            wrapper.eq(SysTemplate::getIsReview, isReview);
        }
        wrapper.orderByDesc(SysTemplate::getCreateTime);
        
        // 执行查询
        return templateMapper.selectPage(pageParam, wrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long addTemplateStage(SysTemplateStage stage) {
        // 检查模板是否存在
        SysTemplate template = templateMapper.selectById(stage.getTemplateId());
        if (template == null) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "模板不存在");
        }
        
        // 插入阶段
        templateStageMapper.insert(stage);
        
        return stage.getId();
    }

    @Override
    public void updateTemplateStage(SysTemplateStage stage) {
        // 检查阶段是否存在
        SysTemplateStage existingStage = templateStageMapper.selectById(stage.getId());
        if (existingStage == null) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "模板阶段不存在");
        }
        
        // 更新阶段
        templateStageMapper.updateById(stage);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteTemplateStage(Long stageId) {
        // 检查阶段是否存在
        SysTemplateStage stage = templateStageMapper.selectById(stageId);
        if (stage == null) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "模板阶段不存在");
        }
        
        // 删除阶段
        templateStageMapper.deleteById(stageId);
    }

    @Override
    public List<SysTemplateStage> getTemplateStages(Long templateId) {
        // 检查模板是否存在
        SysTemplate template = templateMapper.selectById(templateId);
        if (template == null) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "模板不存在");
        }
        
        // 查询模板阶段
        LambdaQueryWrapper<SysTemplateStage> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysTemplateStage::getTemplateId, templateId);
        wrapper.orderByAsc(SysTemplateStage::getCreateTime);
        
        return templateStageMapper.selectList(wrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long addTemplateReview(SysTemplateReview review) {
        // 检查模板是否存在
        SysTemplate template = templateMapper.selectById(review.getTemplateId());
        if (template == null) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "模板不存在");
        }
        
        // 检查评分范围
        if (review.getRating() < 1 || review.getRating() > 5) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "评分必须在1-5之间");
        }
        
        // 插入评价
        templateReviewMapper.insert(review);
        
        // 更新模板评分
        updateTemplateRating(review.getTemplateId());
        
        return review.getId();
    }

    @Override
    public Page<SysTemplateReview> listTemplateReviews(Long templateId, int page, int size) {
        // 检查模板是否存在
        SysTemplate template = templateMapper.selectById(templateId);
        if (template == null) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "模板不存在");
        }
        
        // 创建分页对象
        Page<SysTemplateReview> pageParam = new Page<>(page, size);
        
        // 构建查询条件
        LambdaQueryWrapper<SysTemplateReview> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysTemplateReview::getTemplateId, templateId);
        wrapper.orderByDesc(SysTemplateReview::getCreateTime);
        
        // 执行查询
        return templateReviewMapper.selectPage(pageParam, wrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean purchaseTemplate(Long userId, Long templateId) {
        // 检查模板是否存在
        SysTemplate template = templateMapper.selectById(templateId);
        if (template == null) {
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "模板不存在");
        }

        
        // 检查是否已购买
        if (hasUserPurchasedTemplate(userId, templateId)) {
            return false;
        }

        //是否是创建人
        if (template.getCreateBy().equals(userId)){
            throw new BusinessException(ResultCode.VALIDATE_FAILED.getCode(), "不能购买自己的模板");
        }

        //购买者扣减，创建人加钱
        userMapper.update(new LambdaUpdateWrapper<User>()
                .eq(User::getId, userId)
                .set(User::getMoney, userMapper.selectById(userId).getMoney()-template.getPrice().doubleValue()));
        userMapper.update(new LambdaUpdateWrapper<User>()
                .eq(User::getId, template.getCreateBy())
                .set(User::getMoney, userMapper.selectById(template.getCreateBy()).getMoney()+template.getPrice().doubleValue()));


        
        // 添加购买记录
        SysTemplateUser templateUser = new SysTemplateUser();
        templateUser.setUserId(userId);
        templateUser.setTemplateId(templateId);
        templateUserMapper.insert(templateUser);


        
        return true;
    }

    @Override
    public boolean hasUserPurchasedTemplate(Long userId, Long templateId) {
        LambdaQueryWrapper<SysTemplateUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysTemplateUser::getUserId, userId)
               .eq(SysTemplateUser::getTemplateId, templateId);
        
        return templateUserMapper.selectCount(wrapper) > 0;
    }

    @Override
    public Page<SysTemplate> getUserPurchasedTemplates(Long userId, int page, int size) {
        // 创建分页对象
        Page<SysTemplate> pageParam = new Page<>(page, size);
        
        // 查询用户购买的模板ID列表
        LambdaQueryWrapper<SysTemplateUser> userWrapper = new LambdaQueryWrapper<>();
        userWrapper.eq(SysTemplateUser::getUserId, userId);
        List<SysTemplateUser> templateUsers = templateUserMapper.selectList(userWrapper);
        
        if (templateUsers.isEmpty()) {
            // 用户没有购买任何模板
            Page<SysTemplate> result = new Page<>();
            result.setCurrent(pageParam.getCurrent());
            result.setSize(pageParam.getSize());
            result.setTotal(0);
            result.setRecords(List.of());
            return result;
        }
        
        // 获取模板ID列表
        List<Long> templateIds = templateUsers.stream()
                .map(SysTemplateUser::getTemplateId)
                .collect(java.util.stream.Collectors.toList());
        
        // 构建查询条件
        LambdaQueryWrapper<SysTemplate> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(SysTemplate::getId, templateIds);
        wrapper.orderByDesc(SysTemplate::getCreateTime);
        
        // 执行查询
        return templateMapper.selectPage(pageParam, wrapper);
    }

    @Override
    public List<SysTemplateBo> getlistUserPurchasedTemplates(Long userId) {
        // 查询用户购买的模板ID列表
        LambdaQueryWrapper<SysTemplateUser> userWrapper = new LambdaQueryWrapper<>();
        userWrapper.eq(SysTemplateUser::getUserId, userId);
        List<SysTemplateUser> templateUsers = templateUserMapper.selectList(userWrapper);

        if (templateUsers.isEmpty()) {
            // 用户没有购买任何模板
            List<SysTemplateBo> result = new ArrayList<>();
            return result;
        }

        // 获取模板ID列表
        List<Long> templateIds = templateUsers.stream()
                .map(SysTemplateUser::getTemplateId)
                .collect(java.util.stream.Collectors.toList());

        // 构建查询条件
        LambdaQueryWrapper<SysTemplate> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(SysTemplate::getId, templateIds);
        wrapper.orderByDesc(SysTemplate::getCreateTime);
         List <SysTemplateBo> result = templateMapper.selectList(wrapper).stream()
                .map(template -> {
                    SysTemplateBo templateBo = new SysTemplateBo();
                    BeanUtils.copyProperties(template, templateBo);
                    return templateBo;
                })
                .collect(java.util.stream.Collectors.toList());

         result.forEach(templateBo -> {
            // 模板阶段表
             templateBo.setStages(getTemplateStages(templateBo.getId()));
         });
         return result;
    }

    /**
     * 更新模板评分
     * @param templateId 模板ID
     */
    private void updateTemplateRating(Long templateId) {
        // 查询模板所有评价
        LambdaQueryWrapper<SysTemplateReview> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysTemplateReview::getTemplateId, templateId);
        List<SysTemplateReview> reviews = templateReviewMapper.selectList(wrapper);
        
        if (reviews.isEmpty()) {
            return;
        }
        
        // 计算平均评分
        double totalRating = reviews.stream()
                .mapToInt(SysTemplateReview::getRating)
                .sum();
        BigDecimal avgRating = BigDecimal.valueOf(totalRating / reviews.size())
                .setScale(1, RoundingMode.HALF_UP);
        
        // 更新模板评分
        SysTemplate template = new SysTemplate();
        template.setId(templateId);
        template.setRating(avgRating);
        templateMapper.updateById(template);
    }
}